مدار شکن پایتون: ساخت برنامه‌های با تحمل خطا

در دنیای سیستم‌های توزیع شده و میکروسرویس‌ها، مواجهه با خطاها اجتناب‌ناپذیر است. سرویس‌ها می‌توانند به دلیل مشکلات شبکه، سرورهای پر ترافیک یا باگ‌های غیرمنتظره در دسترس نباشند. هنگامی که یک سرویس در حال خطا به درستی مدیریت نشود، می‌تواند منجر به خرابی‌های آبشاری شده و کل سیستم‌ها را از کار بیندازد. الگوی مدار شکن یک تکنیک قدرتمند برای جلوگیری از این خرابی‌های آبشاری و ساخت برنامه‌های مقاوم‌تر است. این مقاله راهنمای جامعی برای پیاده‌سازی الگوی مدار شکن در پایتون ارائه می‌دهد.

مدار شکن چیست؟

الگوی مدار شکن، با الهام از قطع کننده‌های مدار الکتریکی، به عنوان یک پروکسی برای عملیاتی عمل می‌کند که ممکن است با شکست مواجه شوند. این الگو نرخ موفقیت و شکست این عملیات را رصد می‌کند و هنگامی که به آستانه مشخصی از خطاها می‌رسد، مدار را "قطع" می‌کند و از فراخوانی‌های بعدی به سرویس در حال خطا جلوگیری می‌کند. این امر به سرویس در حال خطا فرصت می‌دهد تا بدون اینکه با درخواست‌ها تحت فشار قرار گیرد، بازیابی شود و از اتلاف منابع توسط سرویس فراخواننده در تلاش برای اتصال به سرویسی که مشخص شده از کار افتاده است، جلوگیری می‌کند.

مدار شکن دارای سه حالت اصلی است:

• بسته (Closed): مدار شکن در حالت عادی خود قرار دارد و اجازه می‌دهد فراخوانی‌ها به سرویس محافظت شده عبور کنند. این حالت موفقیت و شکست این فراخوانی‌ها را رصد می‌کند.
• باز (Open): مدار شکن قطع شده است و تمام فراخوانی‌ها به سرویس محافظت شده مسدود می‌شوند. پس از گذشت یک دوره زمانی مشخص، مدار شکن به حالت نیمه باز (Half-Open) منتقل می‌شود.
• نیمه باز (Half-Open): مدار شکن اجازه تعداد محدودی فراخوانی آزمایشی به سرویس محافظت شده را می‌دهد. اگر این فراخوانی‌ها موفقیت‌آمیز باشند، مدار شکن به حالت بسته باز می‌گردد. اگر ناموفق باشند، به حالت باز باز می‌گردد.

یک قیاس ساده: تصور کنید سعی دارید از دستگاه خودپرداز پول برداشت کنید. اگر دستگاه خودپرداز مکرراً از ارائه پول نقد خودداری کند (احتمالاً به دلیل خطای سیستمی در بانک)، یک مدار شکن وارد عمل می‌شود. مدار شکن به جای ادامه تلاش برای برداشت‌هایی که احتمالاً شکست می‌خورند، به طور موقت از تلاش‌های بعدی جلوگیری می‌کند (حالت باز). پس از مدتی، ممکن است اجازه یک فراخوانی برداشت (حالت نیمه باز) را بدهد. اگر آن تلاش موفقیت‌آمیز باشد، مدار شکن به عملیات عادی (حالت بسته) باز می‌گردد. اگر شکست بخورد، مدار شکن برای مدت طولانی‌تری در حالت باز باقی می‌ماند.

چرا از مدار شکن استفاده کنیم؟

پیاده‌سازی مدار شکن مزایای متعددی را ارائه می‌دهد:

• جلوگیری از خرابی‌های آبشاری: با مسدود کردن فراخوانی‌ها به یک سرویس در حال خطا، مدار شکن از گسترش خطا به سایر بخش‌های سیستم جلوگیری می‌کند.
• بهبود مقاومت سیستم: مدار شکن به سرویس‌های در حال خطا فرصت می‌دهد تا بدون تحت فشار قرار گرفتن توسط درخواست‌ها، بازیابی شوند که منجر به سیستمی پایدارتر و مقاوم‌تر می‌شود.
• کاهش مصرف منابع: با جلوگیری از فراخوانی‌های غیرضروری به سرویس در حال خطا، مدار شکن مصرف منابع را در سرویس فراخواننده و فراخوانده شده کاهش می‌دهد.
• ارائه مکانیزم‌های جایگزین (Fallback): هنگامی که مدار باز است، سرویس فراخواننده می‌تواند یک مکانیزم جایگزین اجرا کند، مانند بازگرداندن یک مقدار کش شده یا نمایش پیام خطا، که تجربه کاربری بهتری را فراهم می‌کند.

پیاده‌سازی مدار شکن در پایتون

راه‌های مختلفی برای پیاده‌سازی الگوی مدار شکن در پایتون وجود دارد. می‌توانید پیاده‌سازی خود را از ابتدا بسازید، یا از یک کتابخانه شخص ثالث استفاده کنید. در اینجا، هر دو رویکرد را بررسی خواهیم کرد.

۱. ساخت مدار شکن سفارشی

بیایید با یک پیاده‌سازی پایه و سفارشی برای درک مفاهیم اصلی شروع کنیم. این مثال از ماژول `threading` برای ایمنی رشته‌ای و ماژول `time` برای مدیریت زمان‌بندی استفاده می‌کند.

            
import time
import threading

class CircuitBreaker:
    def __init__(self, failure_threshold, recovery_timeout):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.state = "CLOSED"
        self.failure_count = 0
        self.last_failure_time = None
        self.lock = threading.Lock()

    def call(self, func, *args, **kwargs):
        with self.lock:
            if self.state == "OPEN":
                if time.time() - self.last_failure_time > self.recovery_timeout:
                    self.state = "HALF_OPEN"
                else:
                    raise CircuitBreakerError("Circuit breaker is open")

        try:
            result = func(*args, **kwargs)
            self.reset()
            return result
        except Exception as e:
            self.record_failure()
            raise e

    def record_failure(self):
        with self.lock:
            self.failure_count += 1
            self.last_failure_time = time.time()

            if self.failure_count >= self.failure_threshold:
                self.state = "OPEN"
                print("Circuit breaker opened")

    def reset(self):
        with self.lock:
            self.failure_count = 0
            self.state = "CLOSED"
            print("Circuit breaker closed")

class CircuitBreakerError(Exception):
    pass

# Example Usage
def unreliable_service():
    # Simulate a service that sometimes fails
    import random
    if random.random() < 0.5:
        raise Exception("Service failed")
    else:
        return "Service successful"

circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=10)

for i in range(10):
    try:
        result = circuit_breaker.call(unreliable_service)
        print(f"Call {i+1}: {result}")
    except CircuitBreakerError as e:
        print(f"Call {i+1}: {e}")
    except Exception as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1) 

            

              
                Copy
              
            
          

توضیح:

• کلاس `CircuitBreaker`:
  • `__init__(self, failure_threshold, recovery_timeout)`: مدار شکن را با آستانه خطا (تعداد خطاها قبل از قطع مدار) و زمان بازیابی (مدت زمان انتظار قبل از تلاش برای حالت نیمه باز) مقداردهی اولیه می‌کند و حالت اولیه را `CLOSED` تنظیم می‌کند.
  • `call(self, func, *args, **kwargs)`: این متد اصلی است که تابعی را که می‌خواهید محافظت کنید، در بر می‌گیرد. وضعیت فعلی مدار شکن را بررسی می‌کند. اگر `OPEN` باشد، زمان سپری شده از آخرین خطا را بررسی می‌کند. اگر زمان بازیابی گذشته باشد، به `HALF_OPEN` منتقل می‌شود. در غیر این صورت، یک `CircuitBreakerError` ایجاد می‌کند. اگر وضعیت `OPEN` نباشد، تابع را اجرا کرده و استثناهای احتمالی را مدیریت می‌کند.
  • `record_failure(self)`: تعداد خطاها را افزایش داده و زمان وقوع خطا را ثبت می‌کند. اگر تعداد خطاها از آستانه فراتر رود، مدار را به حالت `OPEN` منتقل می‌کند.
  • `reset(self)`: تعداد خطاها را بازنشانی کرده و مدار را به حالت `CLOSED` منتقل می‌کند.
• کلاس `CircuitBreakerError`: یک استثنای سفارشی است که هنگام باز بودن مدار شکن ایجاد می‌شود.
• تابع `unreliable_service()`: یک سرویس را که به طور تصادفی خطا می‌دهد، شبیه‌سازی می‌کند.
• مثال استفاده: نحوه استفاده از کلاس `CircuitBreaker` برای محافظت از تابع `unreliable_service()` را نشان می‌دهد.

ملاحظات کلیدی برای پیاده‌سازی سفارشی:

• ایمنی رشته‌ای (Thread Safety): `threading.Lock()` برای اطمینان از ایمنی رشته‌ای، به ویژه در محیط‌های همزمان، حیاتی است.
• مدیریت خطا: بلوک `try...except` استثناهای سرویس محافظت شده را دریافت کرده و `record_failure()` را فراخوانی می‌کند.
• انتقال حالت: منطق انتقال بین حالت‌های `CLOSED`، `OPEN` و `HALF_OPEN` در متدهای `call()` و `record_failure()` پیاده‌سازی شده است.

۲. استفاده از کتابخانه شخص ثالث: `pybreaker`

در حالی که ساخت مدار شکن سفارشی می‌تواند تجربه آموزشی خوبی باشد، استفاده از یک کتابخانه شخص ثالث که به خوبی آزمایش شده است، اغلب گزینه بهتری برای محیط‌های تولید است. یکی از کتابخانه‌های محبوب پایتون برای پیاده‌سازی الگوی مدار شکن `pybreaker` است.

نصب:

            
pip install pybreaker

            

              
                Copy
              
            
          

مثال استفاده:

            
import pybreaker
import time

# Define a custom exception for our service
class ServiceError(Exception):
    pass

# Simulate an unreliable service
def unreliable_service():
    import random
    if random.random() < 0.5:
        raise ServiceError("Service failed")
    else:
        return "Service successful"

# Create a CircuitBreaker instance
circuit_breaker = pybreaker.CircuitBreaker(
    fail_max=3,  # Number of failures before opening the circuit
    reset_timeout=10,  # Time in seconds before attempting to close the circuit
    name="MyService"
)

# Wrap the unreliable service with the CircuitBreaker
@circuit_breaker
def call_unreliable_service():
    return unreliable_service()

# Make calls to the service
for i in range(10):
    try:
        result = call_unreliable_service()
        print(f"Call {i+1}: {result}")
    except pybreaker.CircuitBreakerError as e:
        print(f"Call {i+1}: Circuit breaker is open: {e}")
    except ServiceError as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1)

            

              
                Copy
              
            
          

توضیح:

• نصب: دستور `pip install pybreaker` کتابخانه را نصب می‌کند.
• کلاس `pybreaker.CircuitBreaker`:
  • `fail_max`: تعداد خطاهای متوالی قبل از باز شدن مدار شکن را مشخص می‌کند.
  • `reset_timeout`: زمان (به ثانیه) که مدار شکن باز می‌ماند قبل از انتقال به حالت نیمه باز را مشخص می‌کند.
  • `name`: نام توصیفی برای مدار شکن.
• دکوراتور (Decorator): دکوراتور `@circuit_breaker` تابع `unreliable_service()` را در بر می‌گیرد و منطق مدار شکن را به طور خودکار مدیریت می‌کند.
• مدیریت خطا: بلوک `try...except` هنگام باز بودن مدار، `pybreaker.CircuitBreakerError` و هنگام خطای سرویس (استثنای سفارشی ما)، `ServiceError` را دریافت می‌کند.

مزایای استفاده از `pybreaker`:

• پیاده‌سازی ساده شده: `pybreaker` یک API تمیز و آسان برای استفاده فراهم می‌کند و کد تکراری را کاهش می‌دهد.
• ایمنی رشته‌ای: `pybreaker` رشته‌ای امن است و آن را برای برنامه‌های همزمان مناسب می‌سازد.
• قابل سفارشی‌سازی: می‌توانید پارامترهای مختلفی مانند آستانه خطا، زمان بازیابی و شنوندگان رویداد را پیکربندی کنید.
• شنوندگان رویداد: `pybreaker` از شنوندگان رویداد پشتیبانی می‌کند و به شما امکان می‌دهد وضعیت مدار شکن را نظارت کرده و اقدامات لازم را انجام دهید (مانند ثبت گزارش، ارسال هشدار).

۳. مفاهیم پیشرفته مدار شکن

فراتر از پیاده‌سازی پایه، چندین مفهوم پیشرفته وجود دارد که باید هنگام استفاده از مدارهای شکن در نظر بگیرید:

• معیارها و نظارت: جمع‌آوری معیارها در مورد عملکرد مدارهای شکن شما برای درک رفتار آنها و شناسایی مشکلات بالقوه ضروری است. کتابخانه‌هایی مانند Prometheus و Grafana می‌توانند برای تجسم این معیارها استفاده شوند. معیارهایی مانند موارد زیر را ردیابی کنید:
• وضعیت مدار شکن (باز، بسته، نیمه باز)
• تعداد فراخوانی‌های موفق
• تعداد فراخوانی‌های ناموفق
• تأخیر فراخوانی‌ها
• مکانیزم‌های جایگزین (Fallback Mechanisms): هنگامی که مدار باز است، شما نیاز به یک استراتژی برای مدیریت درخواست‌ها دارید. مکانیزم‌های جایگزین رایج عبارتند از:
• بازگرداندن یک مقدار کش شده.
• نمایش پیام خطا به کاربر.
• فراخوانی یک سرویس جایگزین.
• بازگرداندن یک مقدار پیش‌فرض.
• مدارهای شکن ناهمزمان (Asynchronous Circuit Breakers): در برنامه‌های ناهمزمان (با استفاده از `asyncio`)، باید از پیاده‌سازی مدار شکن ناهمزمان استفاده کنید. برخی کتابخانه‌ها پشتیبانی ناهمزمان را ارائه می‌دهند.
• Bulkheads: الگوی Bulkhead بخش‌هایی از یک برنامه را ایزوله می‌کند تا از گسترش خطاها در یک بخش به سایر بخش‌ها جلوگیری شود. مدارهای شکن را می‌توان در کنار Bulkheads برای ارائه تحمل خطای بیشتر استفاده کرد.
• مدارهای شکن مبتنی بر زمان: به جای ردیابی تعداد خطاها، یک مدار شکن مبتنی بر زمان، مدار را باز می‌کند اگر میانگین زمان پاسخگویی سرویس محافظت شده در یک پنجره زمانی معین از یک آستانه مشخص فراتر رود.

نمونه‌های عملی و موارد استفاده

در اینجا چند نمونه عملی از چگونگی استفاده از مدارهای شکن در سناریوهای مختلف آورده شده است:

• معماری میکروسرویس: در معماری میکروسرویس، سرویس‌ها اغلب به یکدیگر وابسته هستند. یک مدار شکن می‌تواند از تحت فشار قرار گرفتن یک سرویس توسط خطاهای یک سرویس پایین‌دستی جلوگیری کند. به عنوان مثال، یک برنامه تجارت الکترونیک ممکن است میکروسرویس‌های جداگانه‌ای برای فهرست محصولات، پردازش سفارش و پردازش پرداخت داشته باشد. اگر سرویس پردازش پرداخت در دسترس نباشد، یک مدار شکن در سرویس پردازش سفارش می‌تواند از ایجاد سفارشات جدید جلوگیری کند و از خرابی آبشاری جلوگیری نماید.
• اتصالات پایگاه داده: اگر برنامه شما به طور مکرر به پایگاه داده متصل می‌شود، یک مدار شکن می‌تواند از طوفان‌های اتصال هنگام در دسترس نبودن پایگاه داده جلوگیری کند. برنامه‌ای را در نظر بگیرید که به یک پایگاه داده توزیع شده جغرافیایی متصل می‌شود. اگر قطعی شبکه بر یکی از مناطق پایگاه داده تأثیر بگذارد، یک مدار شکن می‌تواند از تلاش‌های مکرر برنامه برای اتصال به منطقه در دسترس نباشد، جلوگیری کند و عملکرد و پایداری را بهبود بخشد.
• APIهای خارجی: هنگام فراخوانی APIهای خارجی، یک مدار شکن می‌تواند برنامه شما را از خطاهای گذرا و قطعی‌ها محافظت کند. بسیاری از سازمان‌ها برای عملکردهای مختلف به APIهای شخص ثالث متکی هستند. با در بر گرفتن فراخوانی‌های API با یک مدار شکن، سازمان‌ها می‌توانند ادغام‌های قوی‌تری بسازند و تأثیر خطاهای API خارجی را کاهش دهند.
• منطق تلاش مجدد (Retry Logic): مدارهای شکن می‌توانند در کنار منطق تلاش مجدد کار کنند. با این حال، مهم است که از تلاش‌های تهاجمی که می‌تواند مشکل را تشدید کند، اجتناب شود. مدار شکن باید از تلاش‌های مجدد در زمانی که سرویس مشخص شده در دسترس نیست، جلوگیری کند.

ملاحظات جهانی

هنگام پیاده‌سازی مدارهای شکن در یک زمینه جهانی، توجه به موارد زیر مهم است:

• تأخیر شبکه (Network Latency): تأخیر شبکه می‌تواند بسته به موقعیت جغرافیایی سرویس‌های فراخواننده و فراخوانده شده به طور قابل توجهی متفاوت باشد. زمان بازیابی را مطابق با آن تنظیم کنید. به عنوان مثال، فراخوانی‌ها بین سرویس‌ها در آمریکای شمالی و اروپا ممکن است تأخیر بیشتری نسبت به فراخوانی‌ها در همان منطقه تجربه کنند.
• مناطق زمانی: اطمینان حاصل کنید که تمام زمان‌بندی‌ها در مناطق زمانی مختلف به طور سازگار مدیریت می‌شوند. از UTC برای ذخیره زمان‌بندی‌ها استفاده کنید.
• قطعی‌های منطقه‌ای: امکان قطعی‌های منطقه‌ای را در نظر بگیرید و مدارهای شکن را برای ایزوله کردن خطاها در مناطق خاص پیاده‌سازی کنید.
• ملاحظات فرهنگی: هنگام طراحی مکانیزم‌های جایگزین، زمینه فرهنگی کاربران خود را در نظر بگیرید. به عنوان مثال، پیام‌های خطا باید محلی‌سازی شده و از نظر فرهنگی مناسب باشند.

بهترین شیوه‌ها

در اینجا چند بهترین شیوه برای استفاده مؤثر از مدارهای شکن آورده شده است:

• با تنظیمات محافظه‌کارانه شروع کنید: با آستانه خطای نسبتاً پایین و زمان بازیابی طولانی‌تر شروع کنید. رفتار مدار شکن را نظارت کرده و تنظیمات را در صورت نیاز تنظیم کنید.
• از مکانیزم‌های جایگزین مناسب استفاده کنید: مکانیزم‌های جایگزینی را انتخاب کنید که تجربه کاربری خوبی را ارائه دهند و تأثیر خطاها را به حداقل برسانند.
• وضعیت مدار شکن را نظارت کنید: وضعیت مدارهای شکن خود را ردیابی کرده و هشدارها را برای اطلاع‌رسانی هنگام باز بودن مدار تنظیم کنید.
• رفتار مدار شکن را تست کنید: در محیط تست خود، خطاها را شبیه‌سازی کنید تا اطمینان حاصل کنید که مدارهای شکن شما به درستی کار می‌کنند.
• از اتکای بیش از حد به مدارهای شکن خودداری کنید: مدارهای شکن ابزاری برای کاهش خطاها هستند، اما جایگزینی برای رفع علل اساسی آن خطاها نیستند. علل اصلی ناپایداری سرویس را بررسی و رفع کنید.
• ردیابی توزیع شده را در نظر بگیرید: ابزارهای ردیابی توزیع شده (مانند Jaeger یا Zipkin) را برای ردیابی درخواست‌ها در سرویس‌های متعدد ادغام کنید. این می‌تواند به شما در شناسایی علت اصلی خطاها و درک تأثیر مدارهای شکن بر کل سیستم کمک کند.

نتیجه‌گیری

الگوی مدار شکن ابزاری ارزشمند برای ساخت برنامه‌های با تحمل خطا و مقاوم است. با جلوگیری از خرابی‌های آبشاری و دادن فرصت به سرویس‌های در حال خطا برای بازیابی، مدارهای شکن می‌توانند پایداری و در دسترس بودن سیستم را به طور قابل توجهی بهبود بخشند. چه پیاده‌سازی خود را انتخاب کنید و چه از یک کتابخانه شخص ثالث مانند `pybreaker` استفاده کنید، درک مفاهیم اصلی و بهترین شیوه‌های الگوی مدار شکن برای توسعه نرم‌افزارهای قوی و قابل اعتماد در محیط‌های پیچیده و توزیع شده امروزی ضروری است.

با پیاده‌سازی اصول ذکر شده در این راهنما، می‌توانید برنامه‌های پایتون بسازید که در برابر خطاها مقاوم‌تر هستند و تجربه کاربری بهتر و سیستمی پایدارتر را تضمین می‌کنند، صرف نظر از دامنه جهانی شما.